home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / nss / ocsp.h < prev    next >
C/C++ Source or Header  |  2006-04-20  |  21KB  |  538 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the Netscape security libraries.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Netscape Communications Corporation.
  18.  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *
  23.  * Alternatively, the contents of this file may be used under the terms of
  24.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26.  * in which case the provisions of the GPL or the LGPL are applicable instead
  27.  * of those above. If you wish to allow use of your version of this file only
  28.  * under the terms of either the GPL or the LGPL, and not to allow others to
  29.  * use your version of this file under the terms of the MPL, indicate your
  30.  * decision by deleting the provisions above and replace them with the notice
  31.  * and other provisions required by the GPL or the LGPL. If you do not delete
  32.  * the provisions above, a recipient may use your version of this file under
  33.  * the terms of any one of the MPL, the GPL or the LGPL.
  34.  *
  35.  * ***** END LICENSE BLOCK ***** */
  36.  
  37. /*
  38.  * Interface to the OCSP implementation.
  39.  *
  40.  * $Id: ocsp.h,v 1.6 2004/04/25 15:03:03 gerv%gerv.net Exp $
  41.  */
  42.  
  43. #ifndef _OCSP_H_
  44. #define _OCSP_H_
  45.  
  46.  
  47. #include "plarena.h"
  48. #include "seccomon.h"
  49. #include "secoidt.h"
  50. #include "keyt.h"
  51. #include "certt.h"
  52. #include "ocspt.h"
  53.  
  54.  
  55. /************************************************************************/
  56. SEC_BEGIN_PROTOS
  57.  
  58. /*
  59.  * FUNCTION: CERT_EnableOCSPChecking
  60.  *   Turns on OCSP checking for the given certificate database.
  61.  * INPUTS:
  62.  *   CERTCertDBHandle *handle
  63.  *     Certificate database for which OCSP checking will be enabled.
  64.  * RETURN:
  65.  *   Returns SECFailure if an error occurred (likely only problem
  66.  *   allocating memory); SECSuccess otherwise.
  67.  */
  68. extern SECStatus
  69. CERT_EnableOCSPChecking(CERTCertDBHandle *handle);
  70.  
  71. /*
  72.  * FUNCTION: CERT_DisableOCSPChecking
  73.  *   Turns off OCSP checking for the given certificate database.
  74.  *   This routine disables OCSP checking.  Though it will return
  75.  *   SECFailure if OCSP checking is not enabled, it is "safe" to
  76.  *   call it that way and just ignore the return value, if it is
  77.  *   easier to just call it than to "remember" whether it is enabled.
  78.  * INPUTS:
  79.  *   CERTCertDBHandle *handle
  80.  *     Certificate database for which OCSP checking will be disabled.
  81.  * RETURN:
  82.  *   Returns SECFailure if an error occurred (usually means that OCSP
  83.  *   checking was not enabled or status contexts were not initialized --
  84.  *   error set will be SEC_ERROR_OCSP_NOT_ENABLED); SECSuccess otherwise.
  85.  */
  86. extern SECStatus
  87. CERT_DisableOCSPChecking(CERTCertDBHandle *handle);
  88.  
  89. /*
  90.  * FUNCTION: CERT_SetOCSPDefaultResponder
  91.  *   Specify the location and cert of the default responder.
  92.  *   If OCSP checking is already enabled *and* use of a default responder
  93.  *   is also already enabled, all OCSP checking from now on will go directly
  94.  *   to the specified responder.  If OCSP checking is not enabled, or if
  95.  *   it is but use of a default responder is not enabled, the information
  96.  *   will be recorded and take effect whenever both are enabled.
  97.  * INPUTS:
  98.  *   CERTCertDBHandle *handle
  99.  *     Cert database on which OCSP checking should use the default responder.
  100.  *   char *url
  101.  *     The location of the default responder (e.g. "http://foo.com:80/ocsp")
  102.  *     Note that the location will not be tested until the first attempt
  103.  *     to send a request there.
  104.  *   char *name
  105.  *     The nickname of the cert to trust (expected) to sign the OCSP responses.
  106.  *     If the corresponding cert cannot be found, SECFailure is returned.
  107.  * RETURN:
  108.  *   Returns SECFailure if an error occurred; SECSuccess otherwise.
  109.  *   The most likely error is that the cert for "name" could not be found
  110.  *   (probably SEC_ERROR_UNKNOWN_CERT).  Other errors are low-level (no memory,
  111.  *   bad database, etc.).
  112.  */
  113. extern SECStatus
  114. CERT_SetOCSPDefaultResponder(CERTCertDBHandle *handle,
  115.                  const char *url, const char *name);
  116.  
  117. /*
  118.  * FUNCTION: CERT_EnableOCSPDefaultResponder
  119.  *   Turns on use of a default responder when OCSP checking.
  120.  *   If OCSP checking is already enabled, this will make subsequent checks
  121.  *   go directly to the default responder.  (The location of the responder
  122.  *   and the nickname of the responder cert must already be specified.)
  123.  *   If OCSP checking is not enabled, this will be recorded and take effect
  124.  *   whenever it is enabled.
  125.  * INPUTS:
  126.  *   CERTCertDBHandle *handle
  127.  *     Cert database on which OCSP checking should use the default responder.
  128.  * RETURN:
  129.  *   Returns SECFailure if an error occurred; SECSuccess otherwise.
  130.  *   No errors are especially likely unless the caller did not previously
  131.  *   perform a successful call to SetOCSPDefaultResponder (in which case
  132.  *   the error set will be SEC_ERROR_OCSP_NO_DEFAULT_RESPONDER).
  133.  */
  134. extern SECStatus
  135. CERT_EnableOCSPDefaultResponder(CERTCertDBHandle *handle);
  136.  
  137. /*
  138.  * FUNCTION: CERT_DisableOCSPDefaultResponder
  139.  *   Turns off use of a default responder when OCSP checking.
  140.  *   (Does nothing if use of a default responder is not enabled.)
  141.  * INPUTS:
  142.  *   CERTCertDBHandle *handle
  143.  *     Cert database on which OCSP checking should stop using a default
  144.  *     responder.
  145.  * RETURN:
  146.  *   Returns SECFailure if an error occurred; SECSuccess otherwise.
  147.  *   Errors very unlikely (like random memory corruption...).
  148.  */
  149. extern SECStatus
  150. CERT_DisableOCSPDefaultResponder(CERTCertDBHandle *handle);
  151.  
  152. /*
  153.  * -------------------------------------------------------
  154.  * The Functions above are those expected to be used by a client
  155.  * providing OCSP status checking along with every cert verification.
  156.  * The functions below are for OCSP testing, debugging, or clients
  157.  * or servers performing more specialized OCSP tasks.
  158.  * -------------------------------------------------------
  159.  */
  160.  
  161. /*
  162.  * FUNCTION: CERT_CreateOCSPRequest
  163.  *   Creates a CERTOCSPRequest, requesting the status of the certs in 
  164.  *   the given list.
  165.  * INPUTS:
  166.  *   CERTCertList *certList
  167.  *     A list of certs for which status will be requested.
  168.  *     Note that all of these certificates should have the same issuer,
  169.  *     or it's expected the response will be signed by a trusted responder.
  170.  *     If the certs need to be broken up into multiple requests, that
  171.  *     must be handled by the caller (and thus by having multiple calls
  172.  *     to this routine), who knows about where the request(s) are being
  173.  *     sent and whether there are any trusted responders in place.
  174.  *   int64 time
  175.  *     Indicates the time for which the certificate status is to be 
  176.  *     determined -- this may be used in the search for the cert's issuer
  177.  *     but has no effect on the request itself.
  178.  *   PRBool addServiceLocator
  179.  *     If true, the Service Locator extension should be added to the
  180.  *     single request(s) for each cert.
  181.  *   CERTCertificate *signerCert
  182.  *     If non-NULL, means sign the request using this cert.  Otherwise,
  183.  *     do not sign.
  184.  *     XXX note that request signing is not yet supported; see comment in code
  185.  * RETURN:
  186.  *   A pointer to a CERTOCSPRequest structure containing an OCSP request
  187.  *   for the cert list.  On error, null is returned, with an error set
  188.  *   indicating the reason.  This is likely SEC_ERROR_UNKNOWN_ISSUER.
  189.  *   (The issuer is needed to create a request for the certificate.)
  190.  *   Other errors are low-level problems (no memory, bad database, etc.).
  191.  */
  192. extern CERTOCSPRequest *
  193. CERT_CreateOCSPRequest(CERTCertList *certList, int64 time, 
  194.                PRBool addServiceLocator,
  195.                CERTCertificate *signerCert);
  196.  
  197. /*
  198.  * FUNCTION: CERT_AddOCSPAcceptableResponses
  199.  *   Add the AcceptableResponses extension to an OCSP Request.
  200.  * INPUTS:
  201.  *   CERTOCSPRequest *request
  202.  *     The request to which the extension should be added.
  203.  *   SECOidTag responseType0, ...
  204.  *     A list (of one or more) of SECOidTag -- each of the response types
  205.  *     to be added.  The last OID *must* be SEC_OID_PKIX_OCSP_BASIC_RESPONSE.
  206.  *     (This marks the end of the list, and it must be specified because a
  207.  *     client conforming to the OCSP standard is required to handle the basic
  208.  *     response type.)  The OIDs are not checked in any way.
  209.  * RETURN:
  210.  *   SECSuccess if the extension is added; SECFailure if anything goes wrong.
  211.  *   All errors are internal or low-level problems (e.g. no memory).
  212.  */
  213. extern SECStatus
  214. CERT_AddOCSPAcceptableResponses(CERTOCSPRequest *request,
  215.                 SECOidTag responseType0, ...);
  216.  
  217. /* 
  218.  * FUNCTION: CERT_EncodeOCSPRequest
  219.  *   DER encodes an OCSP Request, possibly adding a signature as well.
  220.  *   XXX Signing is not yet supported, however; see comments in code.
  221.  * INPUTS: 
  222.  *   PRArenaPool *arena
  223.  *     The return value is allocated from here.
  224.  *     If a NULL is passed in, allocation is done from the heap instead.
  225.  *   CERTOCSPRequest *request
  226.  *     The request to be encoded.
  227.  *   void *pwArg
  228.  *     Pointer to argument for password prompting, if needed.  (Definitely
  229.  *     not needed if not signing.)
  230.  * RETURN:
  231.  *   Returns a NULL on error and a pointer to the SECItem with the
  232.  *   encoded value otherwise.  Any error is likely to be low-level
  233.  *   (e.g. no memory).
  234.  */
  235. extern SECItem *
  236. CERT_EncodeOCSPRequest(PRArenaPool *arena, CERTOCSPRequest *request, 
  237.                void *pwArg);
  238.  
  239. /*
  240.  * FUNCTION: CERT_DecodeOCSPRequest
  241.  *   Decode a DER encoded OCSP Request.
  242.  * INPUTS:
  243.  *   SECItem *src
  244.  *     Pointer to a SECItem holding DER encoded OCSP Request.
  245.  * RETURN:
  246.  *   Returns a pointer to a CERTOCSPRequest containing the decoded request.
  247.  *   On error, returns NULL.  Most likely error is trouble decoding
  248.  *   (SEC_ERROR_OCSP_MALFORMED_REQUEST), or low-level problem (no memory).
  249.  */
  250. extern CERTOCSPRequest *
  251. CERT_DecodeOCSPRequest(SECItem *src);
  252.  
  253. /*
  254.  * FUNCTION: CERT_DestroyOCSPRequest
  255.  *   Frees an OCSP Request structure.
  256.  * INPUTS:
  257.  *   CERTOCSPRequest *request
  258.  *     Pointer to CERTOCSPRequest to be freed.
  259.  * RETURN:
  260.  *   No return value; no errors.
  261.  */
  262. extern void
  263. CERT_DestroyOCSPRequest(CERTOCSPRequest *request);
  264.  
  265. /*
  266.  * FUNCTION: CERT_DecodeOCSPResponse
  267.  *   Decode a DER encoded OCSP Response.
  268.  * INPUTS:
  269.  *   SECItem *src
  270.  *     Pointer to a SECItem holding DER encoded OCSP Response.
  271.  * RETURN:
  272.  *   Returns a pointer to a CERTOCSPResponse (the decoded OCSP Response);
  273.  *   the caller is responsible for destroying it.  Or NULL if error (either
  274.  *   response could not be decoded (SEC_ERROR_OCSP_MALFORMED_RESPONSE),
  275.  *   it was of an unexpected type (SEC_ERROR_OCSP_UNKNOWN_RESPONSE_TYPE),
  276.  *   or a low-level or internal error occurred).
  277.  */
  278. extern CERTOCSPResponse *
  279. CERT_DecodeOCSPResponse(SECItem *src);
  280.  
  281. /*
  282.  * FUNCTION: CERT_DestroyOCSPResponse
  283.  *   Frees an OCSP Response structure.
  284.  * INPUTS:
  285.  *   CERTOCSPResponse *request
  286.  *     Pointer to CERTOCSPResponse to be freed.
  287.  * RETURN:
  288.  *   No return value; no errors.
  289.  */
  290. extern void
  291. CERT_DestroyOCSPResponse(CERTOCSPResponse *response);
  292.  
  293. /*
  294.  * FUNCTION: CERT_GetEncodedOCSPResponse
  295.  *   Creates and sends a request to an OCSP responder, then reads and
  296.  *   returns the (encoded) response.
  297.  * INPUTS:
  298.  *   PRArenaPool *arena
  299.  *     Pointer to arena from which return value will be allocated.
  300.  *     If NULL, result will be allocated from the heap (and thus should
  301.  *     be freed via SECITEM_FreeItem).
  302.  *   CERTCertList *certList
  303.  *     A list of certs for which status will be requested.
  304.  *     Note that all of these certificates should have the same issuer,
  305.  *     or it's expected the response will be signed by a trusted responder.
  306.  *     If the certs need to be broken up into multiple requests, that
  307.  *     must be handled by the caller (and thus by having multiple calls
  308.  *     to this routine), who knows about where the request(s) are being
  309.  *     sent and whether there are any trusted responders in place.
  310.  *   char *location
  311.  *     The location of the OCSP responder (a URL).
  312.  *   int64 time
  313.  *     Indicates the time for which the certificate status is to be 
  314.  *     determined -- this may be used in the search for the cert's issuer
  315.  *     but has no other bearing on the operation.
  316.  *   PRBool addServiceLocator
  317.  *     If true, the Service Locator extension should be added to the
  318.  *     single request(s) for each cert.
  319.  *   CERTCertificate *signerCert
  320.  *     If non-NULL, means sign the request using this cert.  Otherwise,
  321.  *     do not sign.
  322.  *   void *pwArg
  323.  *     Pointer to argument for password prompting, if needed.  (Definitely
  324.  *     not needed if not signing.)
  325.  * OUTPUTS:
  326.  *   CERTOCSPRequest **pRequest
  327.  *     Pointer in which to store the OCSP request created for the given
  328.  *     list of certificates.  It is only filled in if the entire operation
  329.  *     is successful and the pointer is not null -- and in that case the
  330.  *     caller is then reponsible for destroying it.
  331.  * RETURN:
  332.  *   Returns a pointer to the SECItem holding the response.
  333.  *   On error, returns null with error set describing the reason:
  334.  *    SEC_ERROR_UNKNOWN_ISSUER
  335.  *    SEC_ERROR_CERT_BAD_ACCESS_LOCATION
  336.  *    SEC_ERROR_OCSP_BAD_HTTP_RESPONSE
  337.  *   Other errors are low-level problems (no memory, bad database, etc.).
  338.  */
  339. extern SECItem *
  340. CERT_GetEncodedOCSPResponse(PRArenaPool *arena, CERTCertList *certList,
  341.                 char *location, int64 time,
  342.                 PRBool addServiceLocator,
  343.                 CERTCertificate *signerCert, void *pwArg,
  344.                 CERTOCSPRequest **pRequest);
  345.  
  346. /*
  347.  * FUNCTION: CERT_VerifyOCSPResponseSignature
  348.  *   Check the signature on an OCSP Response.  Will also perform a
  349.  *   verification of the signer's certificate.  Note, however, that a
  350.  *   successful verification does not make any statement about the
  351.  *   signer's *authority* to provide status for the certificate(s),
  352.  *   that must be checked individually for each certificate.
  353.  * INPUTS:
  354.  *   CERTOCSPResponse *response
  355.  *     Pointer to response structure with signature to be checked.
  356.  *   CERTCertDBHandle *handle
  357.  *     Pointer to CERTCertDBHandle for certificate DB to use for verification.
  358.  *   void *pwArg
  359.  *     Pointer to argument for password prompting, if needed.
  360.  *   CERTCertificate *issuerCert
  361.  *     Issuer of the certificate that generated the OCSP request.
  362.  * OUTPUTS:
  363.  *   CERTCertificate **pSignerCert
  364.  *     Pointer in which to store signer's certificate; only filled-in if
  365.  *     non-null.
  366.  * RETURN:
  367.  *   Returns SECSuccess when signature is valid, anything else means invalid.
  368.  *   Possible errors set:
  369.  *    SEC_ERROR_OCSP_MALFORMED_RESPONSE - unknown type of ResponderID
  370.  *    SEC_ERROR_INVALID_TIME - bad format of "ProducedAt" time
  371.  *    SEC_ERROR_UNKNOWN_SIGNER - signer's cert could not be found
  372.  *    SEC_ERROR_BAD_SIGNATURE - the signature did not verify
  373.  *   Other errors are any of the many possible failures in cert verification
  374.  *   (e.g. SEC_ERROR_REVOKED_CERTIFICATE, SEC_ERROR_UNTRUSTED_ISSUER) when
  375.  *   verifying the signer's cert, or low-level problems (no memory, etc.)
  376.  */
  377. extern SECStatus
  378. CERT_VerifyOCSPResponseSignature(CERTOCSPResponse *response,    
  379.                  CERTCertDBHandle *handle, void *pwArg,
  380.                  CERTCertificate **pSignerCert,
  381.                  CERTCertificate *issuerCert);
  382.  
  383. /*
  384.  * FUNCTION: CERT_GetOCSPAuthorityInfoAccessLocation
  385.  *   Get the value of the URI of the OCSP responder for the given cert.
  386.  *   This is found in the (optional) Authority Information Access extension
  387.  *   in the cert.
  388.  * INPUTS:
  389.  *   CERTCertificate *cert
  390.  *     The certificate being examined.
  391.  * RETURN:
  392.  *   char *
  393.  *     A copy of the URI for the OCSP method, if found.  If either the
  394.  *     extension is not present or it does not contain an entry for OCSP,
  395.  *     SEC_ERROR_EXTENSION_NOT_FOUND will be set and a NULL returned.
  396.  *     Any other error will also result in a NULL being returned.
  397.  *     
  398.  *     This result should be freed (via PORT_Free) when no longer in use.
  399.  */
  400. extern char *
  401. CERT_GetOCSPAuthorityInfoAccessLocation(CERTCertificate *cert);
  402.  
  403. /*
  404.  * FUNCTION: CERT_CheckOCSPStatus
  405.  *   Checks the status of a certificate via OCSP.  Will only check status for
  406.  *   a certificate that has an AIA (Authority Information Access) extension
  407.  *   for OCSP *or* when a "default responder" is specified and enabled.
  408.  *   (If no AIA extension for OCSP and no default responder in place, the
  409.  *   cert is considered to have a good status and SECSuccess is returned.)
  410.  * INPUTS:
  411.  *   CERTCertDBHandle *handle
  412.  *     certificate DB of the cert that is being checked
  413.  *   CERTCertificate *cert
  414.  *     the certificate being checked
  415.  *   XXX in the long term also need a boolean parameter that specifies
  416.  *    whether to check the cert chain, as well; for now we check only
  417.  *    the leaf (the specified certificate)
  418.  *   int64 time
  419.  *     time for which status is to be determined
  420.  *   void *pwArg
  421.  *     argument for password prompting, if needed
  422.  * RETURN:
  423.  *   Returns SECSuccess if an approved OCSP responder "knows" the cert
  424.  *   *and* returns a non-revoked status for it; SECFailure otherwise,
  425.  *   with an error set describing the reason:
  426.  *
  427.  *    SEC_ERROR_OCSP_BAD_HTTP_RESPONSE
  428.  *    SEC_ERROR_OCSP_FUTURE_RESPONSE
  429.  *    SEC_ERROR_OCSP_MALFORMED_REQUEST
  430.  *    SEC_ERROR_OCSP_MALFORMED_RESPONSE
  431.  *    SEC_ERROR_OCSP_OLD_RESPONSE
  432.  *    SEC_ERROR_OCSP_REQUEST_NEEDS_SIG
  433.  *    SEC_ERROR_OCSP_SERVER_ERROR
  434.  *    SEC_ERROR_OCSP_TRY_SERVER_LATER
  435.  *    SEC_ERROR_OCSP_UNAUTHORIZED_REQUEST
  436.  *    SEC_ERROR_OCSP_UNAUTHORIZED_RESPONSE
  437.  *    SEC_ERROR_OCSP_UNKNOWN_CERT
  438.  *    SEC_ERROR_OCSP_UNKNOWN_RESPONSE_STATUS
  439.  *    SEC_ERROR_OCSP_UNKNOWN_RESPONSE_TYPE
  440.  *
  441.  *    SEC_ERROR_BAD_SIGNATURE
  442.  *    SEC_ERROR_CERT_BAD_ACCESS_LOCATION
  443.  *    SEC_ERROR_INVALID_TIME
  444.  *    SEC_ERROR_REVOKED_CERTIFICATE
  445.  *    SEC_ERROR_UNKNOWN_ISSUER
  446.  *    SEC_ERROR_UNKNOWN_SIGNER
  447.  *
  448.  *   Other errors are any of the many possible failures in cert verification
  449.  *   (e.g. SEC_ERROR_REVOKED_CERTIFICATE, SEC_ERROR_UNTRUSTED_ISSUER) when
  450.  *   verifying the signer's cert, or low-level problems (error allocating
  451.  *   memory, error performing ASN.1 decoding, etc.).
  452.  */    
  453. extern SECStatus 
  454. CERT_CheckOCSPStatus(CERTCertDBHandle *handle, CERTCertificate *cert,
  455.              int64 time, void *pwArg);
  456. /*
  457.  * FUNCTION: CERT_GetOCSPStatusForCertID
  458.  *  Returns the OCSP status contained in the passed in paramter response
  459.  *  that corresponds to the certID passed in.
  460.  * INPUTS:
  461.  *  CERTCertDBHandle *handle
  462.  *    certificate DB of the cert that is being checked
  463.  *  CERTOCSPResponse *response
  464.  *    the OCSP response we want to retrieve status from.
  465.  *  CERTOCSPCertID *certID
  466.  *    the ID we want to look for from the response.
  467.  *  CERTCertificate *signerCert
  468.  *    the certificate that was used to sign the OCSP response.
  469.  *    must be obtained via a call to CERT_VerifyOCSPResponseSignature.
  470.  *  int64 time
  471.  *    The time at which we're checking the status for.
  472.  *  RETURN:
  473.  *    Return values are the same as those for CERT_CheckOCSPStatus
  474.  */
  475. extern SECStatus
  476. CERT_GetOCSPStatusForCertID(CERTCertDBHandle *handle, 
  477.                 CERTOCSPResponse *response,
  478.                 CERTOCSPCertID   *certID,
  479.                 CERTCertificate  *signerCert,
  480.                             int64             time);
  481.  
  482. /*
  483.  * FUNCTION CERT_GetOCSPResponseStatus
  484.  *   Returns the response status for the response passed.
  485.  * INPUTS:
  486.  *   CERTOCSPResponse *response
  487.  *     The response to query for status
  488.  *  RETURN:
  489.  *    Returns SECSuccess if the response has a successful status value.
  490.  *    Otherwise it returns SECFailure and sets one of the following error
  491.  *    codes via PORT_SetError
  492.  *        SEC_ERROR_OCSP_MALFORMED_REQUEST
  493.  *        SEC_ERROR_OCSP_SERVER_ERROR
  494.  *        SEC_ERROR_OCSP_TRY_SERVER_LATER
  495.  *        SEC_ERROR_OCSP_REQUEST_NEEDS_SIG
  496.  *        SEC_ERROR_OCSP_UNAUTHORIZED_REQUEST
  497.  *        SEC_ERROR_OCSP_UNKNOWN_RESPONSE_STATUS
  498.  */
  499. extern SECStatus
  500. CERT_GetOCSPResponseStatus(CERTOCSPResponse *response);
  501.  
  502. /*
  503.  * FUNCTION CERT_CreateOCSPCertID
  504.  *  Returns the OCSP certID for the certificate passed in.
  505.  * INPUTS:
  506.  *  CERTCertificate *cert
  507.  *    The certificate for which to create the certID for.
  508.  *  int64 time
  509.  *    The time at which the id is requested for.  This is used
  510.  *    to determine the appropriate issuer for the cert since
  511.  *    the issuing CA may be an older expired certificate.
  512.  *  RETURN:
  513.  *    A new copy of a CERTOCSPCertID*.  The memory for this certID
  514.  *    should be freed by calling CERT_DestroyOCSPCertID when the 
  515.  *    certID is no longer necessary.
  516.  */
  517. extern CERTOCSPCertID*
  518. CERT_CreateOCSPCertID(CERTCertificate *cert, int64 time);
  519.  
  520. /*
  521.  * FUNCTION: CERT_DestroyOCSPCertID
  522.  *  Frees the memory associated with the certID passed in.
  523.  * INPUTS:
  524.  *  CERTOCSPCertID* certID
  525.  *    The certID that the caller no longer needs and wants to 
  526.  *    free the associated memory.
  527.  * RETURN:
  528.  *  SECSuccess if freeing the memory was successful.  Returns
  529.  *  SECFailure if the memory passed in was not allocated with
  530.  *  a call to CERT_CreateOCSPCertID.
  531.  */
  532. extern SECStatus
  533. CERT_DestroyOCSPCertID(CERTOCSPCertID* certID);
  534. /************************************************************************/
  535. SEC_END_PROTOS
  536.  
  537. #endif /* _OCSP_H_ */
  538.